/*
package com.kedi.filter;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.kedi.entity.RedisUserInfo;
import com.netflix.zuul.ZuulFilter;
import com.netflix.zuul.context.RequestContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.List;

*/
/**
 * @ClassName LoginFilter
 * @Description
 * @Author ytw
 * @Date 2019/7/2  15:38
 * Version 1.0
 **//*


@Component
public class LoginFilter extends ZuulFilter {

    private Logger logger = LoggerFactory.getLogger(getClass());

    @Autowired
    private StringRedisTemplate redisTemplate;
    */
/**
     * 请求路径标识，允许登录请求放行
     *//*

    private String actionUrl = "login";

    */
/**
     * 老人APP端登录表标识
     *//*

    private String oldAppAction = "as";

    */
/**
     * 老人PC端登录标识
     *//*

    private String oldPcAction = "bs";

    */
/**
     * 社区APP端登录标识
     *//*

    private String commAppAction = "cs";

    */
/**
     * 社区PC端登录标识
     *//*

    private String commPcAction = "ds";


    */
/**
     * 返回值可取：
     * - pre：在请求路由之前执行
     * - route：在请求路由时调用
     * - post：请求路由之后调用， 也就是在route和errror过滤器之后调用
     * - error：处理请求发生错误时调用
     * @return
     *//*

    @Override
    public String filterType() {
        return "pre";
    }

    @Override
    public int filterOrder() {
        //返回值是int，会根据返回值进行定义过滤器的执行顺序，值越小优先级越大
        return 1;
    }

    @Override
    public boolean shouldFilter() {
        //当前过滤器是否被执行，true则执行，false不执行
        return true;
    }

    */
/**
     * 老人APP  /as结尾
     * 老人PC   /bs结尾
     * 社区APP  /cs
     * 社区PC   /ds
     *
     * 角色， 登录方式， 权限，
     *
     * 4个登录方式/
     *//*

    @Override
    public Object run() {

        //1.获取请求上下文
        RequestContext context = RequestContext.getCurrentContext();
        HttpServletRequest request = context.getRequest();
        HttpServletResponse resp = context.getResponse();
        //获取请求地址中的token值
        String token = request.getParameter("token");
        //获取请求完整路径
        String requestUrl = request.getRequestURI();

        //如果说请求带了token值，则表示已经登录过
        if(token == null) {

            //对URL地址进行查看里面是否有login字符串
            int index = requestUrl.indexOf(actionUrl);
            if( index != -1){
                //放行操作   TODO
                logger.info("该请求属于登录请求，不对其进行token校验");
                return null;
            }

            logger.warn("此操作需要先登录系统");
            //没有登录 过，则不进行路由转发
            context.setSendZuulResponse(false);
            context.setResponseStatusCode(200);
            try {
                context.getResponse().getWriter().write("token is empty...");
            } catch (IOException e) {
                e.printStackTrace();
            }
            return null;
        }


        //断是否已经登录   未登录
        String isLogin = redisTemplate.opsForValue().get(token);

        //已经登录
        if(isLogin != null && !isLogin.isEmpty()){

            int length = requestUrl.length();
            String action = requestUrl.substring(length-2, length);
            if(oldAppAction.equals(action)){
                return null;
            }

            //已登录   从redis中获取token   判断登录的端    url符不符合端   符合判断的权限是否包含当前路径资源   如果不包含，不访问，
            //TODO
            RedisUserInfo redisUserInfo = JSON.parseObject(isLogin, RedisUserInfo.class);
            if(redisUserInfo != null){
                List<String> urls = redisUserInfo.getUrls();
                urls.forEach(url -> {
                    //说明当前的url是包含再用户资源中的
                    if(url.equals(requestUrl)){
                        return;
                    }
                });
            }
        }else{
            //说明还未登录，需要执行登录操作  TODO
            int length = requestUrl.length();
            String action = requestUrl.substring(length-2, length);

            if(oldAppAction.equals(action)){
                //转发到老人APP登录页面
                String oldAppUrl = "";
                redirectUrl(resp, oldAppUrl);
            }else if(oldPcAction.equals(action)){
                //转发到老人PC登录页面
                String oldPcUrl = "";
                redirectUrl(resp, oldPcUrl);
            }else if(commAppAction.equals(action)){
                //转发到社区APP登录页面
                String commAppUrl = "";
                redirectUrl(resp, commAppUrl);
            }else if(commPcAction.equals(action)){
                //转发到社区PC登录页面
                String commPcUrl = "";
                redirectUrl(resp, commPcUrl);
            }

        }

        //通过，会进行路由转发
        logger.info("通过，会进行路由转发");
        return null;
    }


    */
/**
     * 重定向页面方法
     * @param resp
     *//*

    public void redirectUrl(HttpServletResponse resp, String url){
        try {
            resp.sendRedirect(url);
        } catch (IOException e) {
            e.printStackTrace();
            logger.error("请求地址转发异常");
        }
    }

}
*/
